const fs = require('fs');
const path = require('path');
const cosService = require('./cosService');

/**
 * 用户共享服务
 * 负责处理多用户间数据共享的逻辑
 */
class UserShareService {
  constructor() {
    // 本地数据文件路径
    this.localDataPath = path.join(__dirname, '../public/project.json');
    
    // 共享数据的云端路径前缀
    this.sharedDataPrefix = 'shared/';
    
    // 共享数据元数据文件路径
    this.sharedMetadataPath = 'shared/metadata.json';
    
    // 共享项目缓存
    this.sharedProjectsCache = null;
    
    // 缓存过期时间 (5分钟)
    this.cacheExpiryMs = 5 * 60 * 1000;
    
    // 最后一次缓存更新时间
    this.lastCacheUpdate = 0;
  }

  /**
   * 获取当前用户的ID
   * 当前版本使用MAC地址或设备ID作为用户标识
   * @returns {string} 用户ID
   */
  async getCurrentUserId() {
    // 实现获取用户唯一标识的逻辑
    // 这里可以使用MAC地址、设备ID等作为用户标识
    // TODO: 实际项目中应该根据实际情况选择合适的用户标识方式
    return 'default-user';
  }

  /**
   * 读取本地项目数据
   * @returns {Object} 项目数据对象
   */
  async readLocalData() {
    try {
      if (fs.existsSync(this.localDataPath)) {
        const content = fs.readFileSync(this.localDataPath, 'utf8');
        return JSON.parse(content);
      }
    } catch (error) {
      console.error('读取本地项目数据失败:', error);
    }
    
    return { projectGroups: [], projects: [] };
  }

  /**
   * 保存本地项目数据
   * @param {Object} data 项目数据对象
   */
  async saveLocalData(data) {
    try {
      fs.writeFileSync(this.localDataPath, JSON.stringify(data, null, 2), 'utf8');
      return true;
    } catch (error) {
      console.error('保存本地项目数据失败:', error);
      return false;
    }
  }

  /**
   * 获取共享项目元数据
   * @returns {Object} 共享项目元数据
   */
  async getSharedMetadata() {
    try {
      // 尝试从云端获取共享元数据
      const result = await cosService.cos.getObject({
        Bucket: cosService.config.Bucket,
        Region: cosService.config.Region,
        Key: this.sharedMetadataPath
      });

      if (result.Body) {
        const jsonContent = result.Body.toString();
        return JSON.parse(jsonContent);
      }
    } catch (error) {
      if (error.code !== 'NoSuchKey') {
        console.error('获取共享元数据失败:', error);
      }
      
      // 如果文件不存在，创建初始元数据
      const initialMetadata = { sharedProjects: [] };
      await this.saveSharedMetadata(initialMetadata);
      return initialMetadata;
    }
    
    return { sharedProjects: [] };
  }

  /**
   * 保存共享项目元数据
   * @param {Object} metadata 共享项目元数据
   */
  async saveSharedMetadata(metadata) {
    try {
      const jsonContent = JSON.stringify(metadata, null, 2);
      
      await cosService.cos.putObject({
        Bucket: cosService.config.Bucket,
        Region: cosService.config.Region,
        Key: this.sharedMetadataPath,
        Body: jsonContent,
        ContentType: 'application/json',
        Headers: {
          'x-cos-meta-updated-by': 'nohost-user-share-service',
          'x-cos-meta-updated-at': new Date().toISOString()
        }
      });
      
      return true;
    } catch (error) {
      console.error('保存共享元数据失败:', error);
      return false;
    }
  }

  /**
   * 分享项目到云端
   * @param {string} projectId 要分享的项目ID
   * @returns {Promise<boolean>} 是否分享成功
   */
  async shareProject(projectId) {
    try {
      // 读取本地数据
      const localData = await this.readLocalData();
      
      // 查找要分享的项目
      const project = localData.projects.find(p => p.id === projectId);
      if (!project) {
        console.error('分享项目失败: 项目不存在', projectId);
        return false;
      }

      // 获取当前用户ID
      const userId = await this.getCurrentUserId();
      
      // 准备共享项目的数据
      const sharedProjectData = {
        ...project,
        sharedBy: userId,
        sharedAt: new Date().toISOString()
      };
      
      // 构建共享项目的云存储路径
      const sharedProjectKey = `${this.sharedDataPrefix}projects/${projectId}.json`;
      
      // 上传共享项目数据到云存储
      const jsonContent = JSON.stringify(sharedProjectData, null, 2);
      await cosService.cos.putObject({
        Bucket: cosService.config.Bucket,
        Region: cosService.config.Region,
        Key: sharedProjectKey,
        Body: jsonContent,
        ContentType: 'application/json',
        Headers: {
          'x-cos-meta-shared-by': userId,
          'x-cos-meta-shared-at': new Date().toISOString()
        }
      });
      
      // 更新共享元数据
      const metadata = await this.getSharedMetadata();
      
      // 检查项目是否已经在共享列表中
      const existingIndex = metadata.sharedProjects.findIndex(p => p.id === projectId);
      
      if (existingIndex >= 0) {
        // 更新已存在的项目信息
        metadata.sharedProjects[existingIndex] = {
          id: projectId,
          name: project.name,
          sharedBy: userId,
          sharedAt: new Date().toISOString(),
          path: sharedProjectKey
        };
      } else {
        // 添加新共享项目
        metadata.sharedProjects.push({
          id: projectId,
          name: project.name,
          sharedBy: userId,
          sharedAt: new Date().toISOString(),
          path: sharedProjectKey
        });
      }
      
      // 保存更新后的元数据
      await this.saveSharedMetadata(metadata);
      
      // 清除缓存，确保下次获取时能读取最新数据
      this.clearCache();
      
      console.log('项目分享成功:', projectId);
      return true;
      
    } catch (error) {
      console.error('分享项目失败:', error);
      return false;
    }
  }

  /**
   * 取消共享项目
   * @param {string} projectId 要取消共享的项目ID
   * @returns {Promise<boolean>} 是否取消成功
   */
  async unshareProject(projectId) {
    try {
      // 获取共享元数据
      const metadata = await this.getSharedMetadata();
      
      // 查找项目在共享列表中的索引
      const projectIndex = metadata.sharedProjects.findIndex(p => p.id === projectId);
      
      if (projectIndex === -1) {
        console.log('项目未共享，无需取消');
        return true;
      }
      
      // 获取项目路径
      const projectPath = metadata.sharedProjects[projectIndex].path;
      
      // 从云存储中删除项目数据
      await cosService.cos.deleteObject({
        Bucket: cosService.config.Bucket,
        Region: cosService.config.Region,
        Key: projectPath
      });
      
      // 从元数据中移除该项目
      metadata.sharedProjects.splice(projectIndex, 1);
      
      // 保存更新后的元数据
      await this.saveSharedMetadata(metadata);
      
      // 清除缓存
      this.clearCache();
      
      console.log('取消项目共享成功:', projectId);
      return true;
      
    } catch (error) {
      console.error('取消项目共享失败:', error);
      return false;
    }
  }

  /**
   * 获取所有共享的项目列表
   * @param {boolean} forceRefresh 是否强制刷新缓存
   * @returns {Promise<Array>} 共享项目列表
   */
  async getSharedProjects(forceRefresh = false) {
    try {
      const now = Date.now();
      
      // 检查缓存是否有效
      if (
        !forceRefresh &&
        this.sharedProjectsCache &&
        (now - this.lastCacheUpdate) < this.cacheExpiryMs
      ) {
        return this.sharedProjectsCache;
      }
      
      // 获取共享元数据
      const metadata = await this.getSharedMetadata();
      
      // 如果没有共享项目，直接返回空数组
      if (!metadata.sharedProjects || metadata.sharedProjects.length === 0) {
        this.sharedProjectsCache = [];
        this.lastCacheUpdate = now;
        return [];
      }
      
      // 从云存储获取所有共享项目的详细信息
      const projects = [];
      
      for (const projectMeta of metadata.sharedProjects) {
        try {
          // 获取项目详情
          const result = await cosService.cos.getObject({
            Bucket: cosService.config.Bucket,
            Region: cosService.config.Region,
            Key: projectMeta.path
          });
          
          if (result.Body) {
            const projectData = JSON.parse(result.Body.toString());
            projects.push(projectData);
          }
        } catch (error) {
          console.error('获取共享项目详情失败:', projectMeta.id, error);
        }
      }
      
      // 更新缓存
      this.sharedProjectsCache = projects;
      this.lastCacheUpdate = now;
      
      return projects;
      
    } catch (error) {
      console.error('获取共享项目列表失败:', error);
      return [];
    }
  }

  /**
   * 导入共享项目到本地
   * @param {string} projectId 要导入的项目ID
   * @returns {Promise<boolean>} 是否导入成功
   */
  async importSharedProject(projectId) {
    try {
      // 获取共享项目列表
      const sharedProjects = await this.getSharedProjects(true);
      
      // 查找要导入的项目
      const projectToImport = sharedProjects.find(p => p.id === projectId);
      
      if (!projectToImport) {
        console.error('导入项目失败: 共享项目不存在', projectId);
        return false;
      }
      
      // 读取本地数据
      const localData = await this.readLocalData();
      
      // 检查项目是否已存在
      const existingIndex = localData.projects.findIndex(p => p.id === projectId);
      
      // 准备导入的项目数据
      const importedProject = {
        ...projectToImport,
        importedAt: new Date().toISOString()
      };
      
      if (existingIndex >= 0) {
        // 更新现有项目
        localData.projects[existingIndex] = importedProject;
      } else {
        // 添加新项目
        localData.projects.push(importedProject);
        
        // 确保项目组存在
        if (!localData.projectGroups.some(g => g.id === importedProject.groupId)) {
          // 如果项目组不存在，添加一个默认项目组
          localData.projectGroups.push({
            id: importedProject.groupId,
            name: '导入的项目组',
            createdAt: new Date().toISOString(),
            updatedAt: new Date().toISOString()
          });
        }
      }
      
      // 保存更新后的本地数据
      await this.saveLocalData(localData);
      
      console.log('导入共享项目成功:', projectId);
      return true;
      
    } catch (error) {
      console.error('导入共享项目失败:', error);
      return false;
    }
  }

  /**
   * 获取合并了共享数据的完整项目列表
   * 包括本地项目和共享项目，去重处理
   * @param {boolean} includeShared 是否包含共享项目
   * @returns {Promise<Object>} 包含项目和项目组的完整数据
   */
  async getMergedData(includeShared = true) {
    try {
      // 读取本地数据
      const localData = await this.readLocalData();
      
      if (!includeShared) {
        return localData;
      }
      
      // 获取共享项目
      const sharedProjects = await this.getSharedProjects();
      
      if (!sharedProjects || sharedProjects.length === 0) {
        return localData;
      }
      
      // 合并项目列表，优先使用本地项目
      const mergedData = { ...localData };
      const localProjectIds = new Set(localData.projects.map(p => p.id));
      
      // 添加不在本地的共享项目
      for (const sharedProject of sharedProjects) {
        if (!localProjectIds.has(sharedProject.id)) {
          mergedData.projects.push({
            ...sharedProject,
            isShared: true // 标记为共享项目
          });
          
          // 确保项目组存在
          if (!mergedData.projectGroups.some(g => g.id === sharedProject.groupId)) {
            // 如果项目组不存在，添加一个共享项目组
            mergedData.projectGroups.push({
              id: sharedProject.groupId,
              name: '共享项目组',
              isShared: true,
              createdAt: new Date().toISOString(),
              updatedAt: new Date().toISOString()
            });
          }
        }
      }
      
      return mergedData;
      
    } catch (error) {
      console.error('获取合并数据失败:', error);
      return await this.readLocalData(); // 失败时返回本地数据
    }
  }

  /**
   * 清除缓存数据
   */
  clearCache() {
    this.sharedProjectsCache = null;
    this.lastCacheUpdate = 0;
  }
}

// 创建单例实例
const userShareService = new UserShareService();

module.exports = userShareService;
